Google Cloud Functions: En omfattende guide til HTTP-triggere

Google Cloud Functions (GCF) er et serverløst utførelsesmiljø som lar deg bygge og koble sammen skytjenester. Med Cloud Functions skriver du enkle, enkeltformålsfunksjoner som er knyttet til hendelser som sendes fra din skyinfrastruktur og tjenester. Funksjonen din blir utført når hendelsen du observerer, oppstår. Denne tilnærmingen lar deg utvikle hendelsesdrevne applikasjoner uten å administrere servere eller kjøretidsmiljøer.

En av de vanligste måtene å trigge en Cloud Function på er via en HTTP-forespørsel. Denne guiden vil dykke ned i verden av HTTP-triggere i Google Cloud Functions, og gi deg kunnskapen til å bygge kraftige, skalerbare og kostnadseffektive applikasjoner.

Hva er HTTP-triggere?

En HTTP-trigger lar deg utføre din Cloud Function som respons på en HTTP-forespørsel. I hovedsak, når en HTTP-forespørsel sendes til en spesifikk URL, vil Google Cloud Functions automatisk utføre den tilhørende funksjonen. Dette gjør HTTP-triggere ideelle for å bygge API-er, webhooks og hendelsesdrevne webapplikasjoner.

Viktige fordeler med å bruke HTTP-triggere:

• Skalerbarhet: Cloud Functions skalerer automatisk for å håndtere innkommende HTTP-forespørsler. Du trenger ikke å bekymre deg for å provisjonere eller administrere servere.
• Kostnadseffektivitet: Du betaler kun for tiden funksjonen din utføres. Når funksjonen din er inaktiv, påløper ingen kostnader.
• Brukervennlighet: Cloud Functions forenkler utviklings- og utrullingsprosessen. Du kan fokusere på å skrive funksjonskoden din, og Google Cloud tar seg av infrastrukturen.
• Integrasjon: HTTP-triggere lar deg enkelt integrere Cloud Functions med andre tjenester, som webapplikasjoner, mobilapper og tredjeparts API-er.

Opprette en Cloud Function med en HTTP-trigger

La oss gå gjennom prosessen med å opprette en enkel Cloud Function med en HTTP-trigger. Vi vil lage en funksjon som svarer med en "Hei, Verden!"-melding. Dette eksemplet kan tilpasses for ulike globale lokasjoner ved å ganske enkelt endre utdatastrengen.

Forutsetninger:

• En Google Cloud Platform (GCP) konto.
• Google Cloud SDK (gcloud) installert og konfigurert.

Steg:

1. Opprett et nytt prosjekt (hvis du ikke har et):

   Hvis du ikke allerede har et GCP-prosjekt, opprett et i Google Cloud Console.

2. Aktiver Cloud Functions API:

   Naviger til Cloud Functions API i Cloud Console og aktiver det.

3. Opprett en funksjonskatalog:

   Opprett en ny katalog for din Cloud Function. For eksempel:

               mkdir hello-http
   cd hello-http
               
   
                 
                   Copy
                 
               
             

4. Skriv funksjonskoden:

   Opprett en fil kalt `main.py` (eller `index.js` for Node.js) med følgende kode:

   Python (main.py):

               def hello_http(request):
       """HTTP Cloud Function.
       Args:
           request (flask.Request): Request-objektet.
           
       Returns:
           Responsteksten, eller et hvilket som helst sett med verdier som kan gjøres om til et
           Response-objekt ved bruk av `make_response`
           `.
       """
       request_json = request.get_json(silent=True)
       request_args = request.args
   
       if request_json and 'name' in request_json:
           name = request_json['name']
       elif request_args and 'name' in request_args:
           name = request_args['name']
       else:
           name = 'World'
       return f'Hello, {name}!'
               
   
                 
                   Copy
                 
               
             

   Node.js (index.js):

               exports.helloHttp = (req, res) => {
     let name = 'World';
     if (req.body.name) {
       name = req.body.name;
     } else if (req.query.name) {
       name = req.query.name;
     }
     res.status(200).send(`Hello, ${name}!`);
   };
   
               
   
                 
                   Copy
                 
               
             

5. Opprett en kravfil (kun Python):

   Hvis du bruker Python, opprett en fil kalt `requirements.txt` og legg til eventuelle avhengigheter funksjonen din trenger. For dette eksemplet er det ikke strengt tatt nødvendig, men det er god praksis å inkludere en. Du kan la den være tom hvis du ikke har noen avhengigheter.

6. Rull ut funksjonen:

   Bruk kommandoen `gcloud functions deploy` for å rulle ut funksjonen din. Erstatt `YOUR_FUNCTION_NAME` med ønsket navn på funksjonen din.

   Python:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime python39 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   Node.js:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime nodejs16 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   Forklaring av parametere:

   • `YOUR_FUNCTION_NAME`: Navnet du vil gi Cloud Function.
   • `--runtime`: Kjøretidsmiljøet for funksjonen din (f.eks. `python39`, `nodejs16`).
   • `--trigger-http`: Spesifiserer at funksjonen skal trigges av HTTP-forespørsler.
   • `--allow-unauthenticated`: Tillater at hvem som helst kan kalle funksjonen uten autentisering. Advarsel: Vær forsiktig med å aktivere dette i produksjonsmiljøer! Vurder å implementere riktig autentisering og autorisasjon.
7. Test funksjonen:

   Etter utrulling vil `gcloud`-kommandoen gi URL-en til funksjonen din. Du kan deretter teste den ved å sende en HTTP-forespørsel til den URL-en ved hjelp av et verktøy som `curl` eller Postman.

               curl YOUR_FUNCTION_URL
               
   
                 
                   Copy
                 
               
             

   Du bør se "Hei, Verden!"-meldingen i responsen. Du kan også sende et navn som en spørringsparameter:

               curl "YOUR_FUNCTION_URL?name=DittNavn"
               
   
                 
                   Copy
                 
               
             

   Dette bør returnere "Hello, DittNavn!"

Forstå HTTP-forespørselen og -responsen

Når en Cloud Function trigges av en HTTP-forespørsel, mottar den et objekt som inneholder informasjon om forespørselen. Dette objektet inkluderer vanligvis:

• Headers: HTTP-headers som ble sendt med forespørselen.
• Body: Forespørselsbrødteksten (f.eks. JSON-data, skjema-data).
• Spørringsparametere: Parametere som ble sendt i URL-en.
• Metode: HTTP-metoden (f.eks. GET, POST, PUT, DELETE).

Funksjonen din bør deretter returnere en HTTP-respons, som inkluderer:

• Statuskode: HTTP-statuskoden (f.eks. 200 OK, 400 Bad Request, 500 Internal Server Error).
• Headers: HTTP-headers som skal sendes med responsen.
• Body: Responskroppen (f.eks. JSON-data, HTML-innhold).

Eksempel: Håndtere forskjellige HTTP-metoder

Her er et eksempel på hvordan du kan håndtere forskjellige HTTP-metoder i din Cloud Function:

Python (main.py):

            from flask import escape

def http_method(request):
    """Svarer på enhver HTTP-forespørsel.
    Args:
        request (flask.Request): HTTP-forespørselsobjekt.
    Returns:
        Responsteksten eller et hvilket som helst sett med verdier som kan gjøres om til et
        Response-objekt ved bruk av
        `make_response``.
    """
    if request.method == 'GET':
        return 'Dette er en GET-forespørsel!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'Dette er en POST-forespørsel med melding: {message}'
        else:
            return 'Dette er en POST-forespørsel uten melding.'
    else:
        return 'Ugyldig HTTP-metode.', 405

            

              
                Copy
              
            
          

Node.js (index.js:

            exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('Dette er en GET-forespørsel!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`Dette er en POST-forespørsel med melding: ${message}`);
      } else {
        res.status(200).send('Dette er en POST-forespørsel uten melding.');
      }
      break;
    default:
      res.status(405).send('Ugyldig HTTP-metode!');
      break;
  }
};

            

              
                Copy
              
            
          

Husk å rulle ut den oppdaterte funksjonen ved hjelp av `gcloud functions deploy`-kommandoen.

Sikring av HTTP-triggerne dine

Sikkerhet er avgjørende når du arbeider med HTTP-triggere, spesielt når du håndterer sensitiv data eller kritiske operasjoner. Her er noen viktige sikkerhetshensyn:

Autentisering og autorisasjon

Som standard er Cloud Functions som trigges av HTTP offentlig tilgjengelige hvis du bruker `--allow-unauthenticated`. I de fleste produksjonsscenarier vil du begrense tilgang til autoriserte brukere eller tjenester. Google Cloud tilbyr flere alternativer for autentisering og autorisasjon:

• Identity-Aware Proxy (IAP): IAP lar deg kontrollere tilgang til Cloud Functions basert på Google-identiteter. Det krever at brukere autentiserer seg med sine Google-kontoer før de får tilgang til funksjonen.
• Tjenestekontoer: Du kan tildele en tjenestekonto til din Cloud Function og bruke den til å autentisere deg med andre Google Cloud-tjenester. Dette er nyttig for å la funksjonen din få tilgang til ressurser som Cloud Storage eller Cloud Datastore.
• Egendefinert autentisering: Du kan implementere din egen autentiseringsmekanisme, som JWT (JSON Web Token) eller API-nøkler. Dette gir deg mest fleksibilitet, men krever også mer utviklingsinnsats.

Inndatavalidering

Valider alltid inndataene som mottas av din Cloud Function for å forhindre sikkerhetssårbarheter som SQL-injeksjon eller cross-site scripting (XSS). Bruk passende sanitiserings- og unntaksteknikker for å beskytte mot ondsinnet inndata.

HTTPS

Sørg for at Cloud Function kun er tilgjengelig via HTTPS for å kryptere kommunikasjonen mellom klienten og funksjonen. Google Cloud Functions tilbyr automatisk HTTPS-endepunkter.

Hastighetsbegrensning

Implementer hastighetsbegrensning for å forhindre misbruk og tjenestenektangrep (DoS). Du kan bruke tjenester som Google Cloud Armor for å beskytte dine Cloud Functions mot overdreven trafikk.

Brukstilfeller for HTTP-triggere

HTTP-triggere er allsidige og kan brukes i et bredt spekter av applikasjoner. Her er noen vanlige brukstilfeller:

• REST API-er: Bygg RESTful API-er for dine web- og mobilapplikasjoner.
• Webhooks: Integrer med tredjepartstjenester ved å motta webhook-hendelser.
• Skjema-behandling: Behandle data som sendes inn via HTML-skjemaer.
• Bildeomstørring: Utløs bildeomstørring når nye bilder lastes opp til Cloud Storage.
• Datatransformasjon: Transformer data fra ett format til et annet.
• Slack-bots: Opprett interaktive Slack-bots.
• Egendefinerte webapplikasjoner: Lever dynamisk innhold for små webapplikasjoner eller mikrotjenester.

Eksempler fra forskjellige bransjer

• E-handel (Globalt): En HTTP-trigger kan brukes til å behandle betalinger fra forskjellige betalingsgatewayer globalt, validere transaksjoner og oppdatere ordrestatus i sanntid. Funksjonen kan bruke geolokasjonsinformasjon fra forespørselen til å anvende riktige skatter og fraktrater basert på brukerens posisjon.
• Finans (Internasjonal bankvirksomhet): HTTP-triggere kan forenkle sikre pengeoverføringer mellom forskjellige bankkontoer globalt, håndtere valutakonverteringer og overholde internasjonale bankforskrifter. Autentisering er avgjørende her, potensielt involverer multifaktorautentisering via SMS eller autentiseringsapper.
• Helsevesen (Telemedisin): En HTTP-trigger kan håndtere timebestillingsforespørsler fra pasienter over hele verden, koordinere med forskjellige tidssoner og administrere legers tilgjengelighet. Den kan også integreres med oversettelsestjenester for å tilby flerspråklig støtte. Databeskyttelse og samsvar med forskrifter som HIPAA (i USA) eller GDPR (i Europa) er avgjørende.
• Utdanning (Nettbaserte læringsplattformer): HTTP-triggere kan brukes til å automatisk vurdere oppgaver, og gi umiddelbar tilbakemelding til studenter uavhengig av deres plassering. De kan også utløse personlige læringsanbefalinger basert på studentens ytelse.
• Logistikk (Global frakt): HTTP-triggere kan brukes til å spore forsendelser i sanntid, og gi oppdateringer om pakkens plassering og estimerte leveringstider til kunder over hele verden. Integrasjoner med ulike fraktleverandører ved bruk av deres API-er via HTTP-triggere er vanlig.

Avanserte teknikker

Bruk av miljøvariabler

Miljøvariabler lar deg konfigurere Cloud Function uten å hardkode sensitiv informasjon eller konfigurasjonsverdier i koden din. Du kan sette miljøvariabler ved bruk av `gcloud functions deploy`-kommandoen eller i Google Cloud Console.

            gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=DIN_API_NØKKEL,DATABASE_URL=DIN_DATABASE_URL
            

              
                Copy
              
            
          

I koden din kan du få tilgang til miljøvariabler ved bruk av `os.environ`-ordlisten (Python) eller `process.env`-objektet (Node.js).

Python:

            import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Bruk API-nøkkelen i funksjonen din
    return f'API Nøkkel: {api_key}'
            

              
                Copy
              
            
          

Node.js:

            exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Bruk API-nøkkelen i funksjonen din
  res.status(200).send(`API Nøkkel: ${apiKey}`);
};

            

              
                Copy
              
            
          

Håndtere asynkrone oppgaver

For langvarige eller beregningsmessig intensive oppgaver er det best å bruke asynkron behandling for å unngå å blokkere HTTP-forespørselen. Du kan bruke tjenester som Google Cloud Tasks eller Cloud Pub/Sub til å laste av disse oppgavene til separate køer.

Feilhåndtering og logging

Implementer robust feilhåndtering og logging i dine Cloud Functions for å identifisere og løse problemer raskt. Bruk Google Cloud Logging for å samle logger fra funksjonene dine og overvåke ytelsen deres.

Beste praksis

• Hold funksjoner små og fokuserte: Hver funksjon bør ha en enkelt, veldefinert hensikt.
• Bruk avhengighetsstyring: Bruk pakkehåndterere som `pip` (Python) eller `npm` (Node.js) for å administrere avhengighetene dine.
• Test funksjonene dine grundig: Skriv enhetstester og integrasjonstester for å sikre at funksjonene dine fungerer korrekt.
• Overvåk funksjonsytelse: Bruk Google Cloud Monitoring for å spore funksjonens utførelsestid, minnebruk og feilrater.
• Optimaliser kode for kalde starter: Minimer tiden det tar for funksjonen din å starte opp (kald start). Dette kan oppnås ved å redusere avhengigheter, optimalisere kode og bruke provisjonert samtidighet (der tilgjengelig).
• Vurder funksjonsplassering: Rull ut funksjonene dine i en region som er geografisk nær brukerne dine for å minimere forsinkelsen. For et globalt publikum, vurder å rulle ut til flere regioner.

Feilsøking av vanlige problemer

• Funksjon feiler ved utrulling: Se etter syntaksfeil i koden din, forsikre deg om at du har de nødvendige tillatelsene, og bekreft at du bruker et støttet kjøretidsmiljø.
• Funksjon returnerer en 500-feil: Sjekk funksjonsloggene i Google Cloud Logging for feilmeldinger. Vanlige årsaker inkluderer uhåndterte unntak, manglende avhengigheter eller feil konfigurasjon.
• Funksjon går ut av tid: Øk funksjonens tidsavbruddsverdi i Google Cloud Console eller ved bruk av `gcloud functions deploy`-kommandoen. Optimaliser også koden din for å redusere utførelsestiden.
• Funksjon utløses ikke: Bekreft at triggere er riktig konfigurert og at HTTP-forespørselen sendes til riktig URL.

Konklusjon

Google Cloud Functions med HTTP-triggere gir en kraftig og fleksibel måte å bygge serverløse applikasjoner på. Ved å forstå konseptene og teknikkene som er diskutert i denne guiden, kan du utnytte kraften i Cloud Functions til å skape skalerbare, kostnadseffektive og hendelsesdrevne løsninger for et globalt publikum. Omfavn den serverløse revolusjonen og lås opp det fulle potensialet i dine skyapplikasjoner!